home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 June: Reference Library / Dev.CD Jun 96 RL / Dev.CD Jun 96 RL.toast / Technical Documentation / develop / develop Issue 26 / develop Issue 26 code / Wide (64 bit) Library / TestWide.c next >
Encoding:
C/C++ Source or Header  |  1996-02-09  |  13.5 KB  |  518 lines  |  [TEXT/CWIE]
  1. #include <console.h>
  2. #include <stdio.h>
  3.  
  4. #include "Wide.h"
  5.  
  6. /* forward references */
  7. void tst_printint( wide *big_ptr );
  8. void tst_print3( wide *big1_ptr, wide *big2_ptr, wide *big3_ptr );
  9. void tst_compare3( wide *big1_ptr, wide *big2_ptr, wide *big3_ptr,
  10.                wide *save1_ptr, wide *save2_ptr, wide *save3_ptr, short equal_test );
  11. void tst_wide( wide *big_ptr, long hi, long lo, char *strp );
  12. void __assertprint(char *filenam_ptr, char *linenum_ptr, char *expression_ptr);
  13. void __assert_custom(char *filenam_ptr, char *linenum_ptr, char *expression_ptr);
  14. void tst_long( long actual, long expected, char *strp );
  15.  
  16.  
  17.  
  18.  
  19. main()
  20. {
  21. short    i;
  22. short    tst1, tst2, tst3;
  23. wide    big1, big2, big3;
  24. wide    save1, save2, save3;
  25. wide    *resultp, *resultAp, *resultBp;
  26. decimal dec_str;
  27. long    result, remainder;
  28.  
  29.         wide    wide1;
  30.         decimal dec;
  31.  
  32.  
  33.         wide1.hi = 0;
  34.         wide1.lo = 0x00000401;
  35.         WideShift(&wide1, 3);
  36.         
  37.         wide1.hi = 0;
  38.         wide1.lo = 0x00000C;
  39.         WideShift(&wide1, 3); // Should be 2 because of rounding
  40.  
  41.  
  42.         wide1.hi = 0;
  43.         wide1.lo = 0;
  44.         WideToDecStr(&dec, &wide1);     /* should be "0" */
  45.  
  46.         wide1.hi = 0;
  47.         wide1.lo = 1;
  48.         WideToDecStr(&dec, &wide1);     /* should be "1" */
  49.  
  50.         WideNegate( &wide1 );
  51.         WideToDecStr(&dec, &wide1);     /* should be Negative "1" */
  52.  
  53.         wide1.hi = 0;
  54.         wide1.lo = 12345;
  55.         WideToDecStr(&dec, &wide1);     /* should be "12345" */
  56.  
  57.         WideNegate( &wide1 );
  58.         WideToDecStr(&dec, &wide1);     /* should be Negative "12345" */
  59.  
  60.         wide1.hi = 1;
  61.         wide1.lo = 0;
  62.         WideToDecStr(&dec, &wide1);     /* should be "4294967296" */
  63.  
  64.         WideNegate( &wide1 );
  65.         WideToDecStr(&dec, &wide1);     /* should be Negative "4294967296" */
  66.  
  67.  
  68.     resultp = WideAssign32( &big1, -1 );
  69.     WideAssign32( &big2, 0 );
  70.     WideAssign32( &big3, 25 );
  71.     save1 = big1;
  72.     save2 = big2;
  73.     save3 = big3;
  74.     printf( "WideAssign32() = " );
  75.     tst_print3( &big1, &big2, &big3 );
  76.  
  77.     WideAdd32( &big1, 3 );
  78.     resultAp = WideAdd32( &big2, -1 );
  79.     WideAdd32( &big3, -30 );
  80.     printf( "WideAdd32() = " );
  81.     tst_print3( &big1, &big2, &big3 );
  82.  
  83.     WideSubtract32( &big1, 3 );
  84.     WideSubtract32( &big2, -1 );
  85.     resultBp = WideSubtract32( &big3, -30 );
  86.     printf( "WideSubtract32() = " );
  87.     tst_print3( resultp, resultAp, resultBp );
  88.     tst_compare3( resultp,resultAp, resultBp, &save1, &save2, &save3, true );
  89.  
  90.     WideAssign32( &big1, 0x40000000 );
  91.     printf( "WideAssign32() = " );
  92.     tst_printint( &big1 ); printf( "\n" );
  93.     WideBitShift( &big1, -2 );
  94.     printf( "WideBitShift(left twice) = " );
  95.     tst_printint( &big1 ); printf( "\n" );
  96.     WideAdd32( &big1, 3507 );
  97.     printf( "WideAdd32(3507)\n\n" );
  98.     WideToDecStr( &dec_str, &big1 );
  99.     if( (dec_str.sgn == 0) &&
  100.         (dec_str.exp == 0) &&
  101.         (dec_str.sig.length == 10) &&
  102.         (dec_str.sig.text[0] == '4') &&
  103.         (dec_str.sig.text[1] == '2') &&
  104.         (dec_str.sig.text[2] == '9') &&
  105.         (dec_str.sig.text[3] == '4') &&
  106.         (dec_str.sig.text[4] == '9') &&
  107.         (dec_str.sig.text[5] == '7') &&
  108.         (dec_str.sig.text[6] == '0') &&
  109.         (dec_str.sig.text[7] == '8') &&
  110.         (dec_str.sig.text[8] == '0') &&
  111.         (dec_str.sig.text[9] == '3') )
  112.         printf( "PASS" );
  113.     else
  114.         printf( "FAIL" );
  115.     printf( ": " );
  116.     tst_printint( &big1 );
  117.     printf( ", WideToDecStr() with more than 32 bits\n\n" );
  118.  
  119.     WideAssign32( &big1, -10 );
  120.     WideAssign32( &big2, 0x7FFFFFF0 );
  121.     WideAssign32( &big3, 0x7FFFFFFF );
  122.     save1 = big1;
  123.     save2 = big2;
  124.     save3 = big3;
  125.     printf( "WideAssign32() = " );
  126.     tst_print3( &big1, &big2, &big3 );
  127.  
  128.     WideAdd32( &big3, 1 );
  129.     resultp = WideAdd( &big3, &big1 );
  130.     for( i=0; i < 20; ++i ) WideAdd( &big3, &big2 );
  131.     printf( "WideAdd() = " );
  132.     tst_print3( &big1, &big2, resultp );
  133.     tst_compare3( &big1, &big2, resultp, &save1, &save2, &save3, false );
  134.  
  135.     /*------------------------------*/
  136.     printf( "<<< press ENTER for more >>>\n\n" );
  137.     getchar();
  138.  
  139.     WideSubtract32( &big3, 1 );
  140.     resultp = WideSubtract( &big3, &big1 );
  141.     for( i=0; i < 20; ++i ) WideSubtract( &big3, &big2 );
  142.  
  143.     printf( "WideSubtract() = " );
  144.     tst_print3( &big1, &big2, resultp );
  145.     tst_compare3( &big1, &big2, resultp, &save1, &save2, &save3, true );
  146.  
  147.     WideAssign32( &big1, 0 );
  148.     WideAssign32( &big2, 7 );
  149.     WideAssign32( &big3, 0x7FFFFFFF );
  150.     save1 = big1;
  151.     save2 = big2;
  152.     save3 = big3;
  153.     printf( "WideAssign32() = " );
  154.     tst_print3( &big1, &big2, &big3 );
  155.  
  156.     WideNegate(  &big1 );
  157.     WideNegate(  &big2 );
  158.     WideNegate(  &big3 );
  159.     printf( "WideNegate() = " );
  160.     tst_print3( &big1, &big2, &big3 );
  161.     printf( "\n" );
  162.  
  163.     WideAssign32( &big3, 1 );
  164.     save3 = big3;
  165.     WideAdd( &big2, &big3 );
  166.     if( (big2.lo == -6) && (big2.hi == -1) )
  167.         printf( "PASS" );
  168.     else
  169.         printf( "FAIL" );
  170.     printf( ": adding a small positive to a small negative\n" );
  171.     WideSubtract( &big2, &big3 );
  172.     if( (big3.lo == save3.lo) && (big3.hi == save3.hi) )
  173.         printf( "PASS" );
  174.     else
  175.         printf( "FAIL" );
  176.     printf( ": subtracting a small positive to a small negative\n\n" );
  177.  
  178.     WideAssign32( &big1, 18 );
  179.     result = WideDivide( &big1, 4, &remainder );
  180.     if( (result == 4) && (remainder == 2) )
  181.         printf( "PASS" );
  182.     else
  183.         printf( "FAIL" );
  184.     printf( ": %ld, %ld, WideDivide()\n",
  185.             result, remainder );
  186.  
  187.     WideAssign32( &big1, 10000 );
  188.     result = WideDivide( &big1, 200, &remainder );
  189.     if( (result == 50) && (remainder == 0) )
  190.         printf( "PASS" );
  191.     else
  192.         printf( "FAIL" );
  193.     printf( ": %ld, %ld, WideDivide()\n",
  194.             result, remainder );
  195.  
  196.     WideMultiply( 10, 307, &big1 );
  197.     result = WideDivide( &big1, 307, &remainder );
  198.     if( (result == 10) && (remainder == 0) )
  199.         printf( "PASS" );
  200.     else
  201.         printf( "FAIL" );
  202.     printf( ": %ld, %ld, WideMultiply() WideDivide(), small positive num.\n",
  203.             result, remainder );
  204.  
  205.     WideMultiply( -6, -3, &big1 );
  206.     result = WideDivide( &big1, -4, &remainder );
  207.     if( (result == -4) && (remainder == 2) )
  208.         printf( "PASS" );
  209.     else
  210.         printf( "FAIL" );
  211.     printf( ": %ld, %ld, WideMultiply() WideDivide(), small negative num.\n",
  212.              result, remainder );
  213.  
  214.     WideMultiply( 0x7FFFFFF3, 0x5A5A, &big1 );
  215.     result = WideDivide( &big1, 0x7FFFFFF3, &remainder );
  216.     if( (result == 0x5A5A) && (remainder == 0) )
  217.         printf( "PASS" );
  218.     else
  219.         printf( "FAIL" );
  220.     printf( ": 0x%lx, %ld, WideMultiply() WideDivide()\n",
  221.              result, remainder );
  222.  
  223.     WideMultiply( -(0x7FFFFFF3), 0x5A5A, &big1 );
  224.     result = WideDivide( &big1, 0x7FFFFFF3, &remainder );
  225.     if( (result == -(0x5A5A)) && (remainder == 0) )
  226.         printf( "PASS" );
  227.     else
  228.         printf( "FAIL" );
  229.     printf( ": 0x%lx, %ld, WideMultiply() WideDivide()\n",
  230.              result, remainder );
  231.  
  232.     /*------------------------------*/
  233.     printf( "<<< press ENTER for more >>>\n\n" );
  234.     getchar();
  235.  
  236.     WideAssign32( &big1, 1 );
  237.     result = WideDivide( &big1, 0, NULL );
  238.     if( result == gxPositiveInfinity )
  239.         printf( "PASS" );
  240.     else
  241.         printf( "FAIL" );
  242.     printf( ": %lx, WideDivide() positive by 0\n", result );
  243.  
  244.     WideAssign32( &big1, -1 );
  245.     result = WideDivide( &big1, 0, NULL );
  246.     if( result == gxNegativeInfinity )
  247.         printf( "PASS" );
  248.     else
  249.         printf( "FAIL" );
  250.     printf( ": %lx, WideDivide() negative by 0\n\n", result );
  251.  
  252.     resultp = WideMultiply( 0, 0, &big1 );
  253.     WideMultiply( -4, -(0x7FFFFFFF), &big2 );
  254.     WideMultiply( -(0x7FFFFFFF), 0x7FFFFFFF, &big3 );
  255.     save1 = big1;
  256.     save2 = big2;
  257.     save3 = big3;
  258.     printf( "WideMultiply(), 0 * 0, -4 * -(0x7FFFFFFF), -(0x7FFFFFFF) * 0x7FFFFFFF =\n" );
  259.     tst_print3( resultp, &big2, &big3 );
  260.  
  261.     WideNegate(  &big1 );
  262.     WideNegate(  &big2 );
  263.     WideNegate(  &big3 );
  264.     printf( "WideNegate() = " );
  265.     tst_print3( &big1, &big2, &big3 );
  266.     printf( "\n" );
  267.  
  268.     result = WideDivide( &big2, -4, NULL );
  269.     if( result == 0x7FFFFFFF )
  270.         printf( "PASS" );
  271.     else
  272.         printf( "FAIL" );
  273.     printf( ": WideDivide() = 0x%lx\n", result );
  274.  
  275.     WideNegate(  &big3 );
  276.     result = WideDivide( &big3, 0x7FFFFFFF, NULL );
  277.     if( result == -(0x7FFFFFFF) )
  278.         printf( "PASS" );
  279.     else
  280.         printf( "FAIL" );
  281.     printf( ": WideDivide() = 0x%lx\n", result );
  282.  
  283.     WideAssign32( &big1, 25 );
  284.     resultp = WideWideDivide( &big1, 3, &remainder );
  285.     if( (resultp->lo == 8) && (resultp->hi == 0) && (remainder == 1) )
  286.         printf( "PASS" );
  287.     else
  288.         printf( "FAIL" );
  289.     printf( ": %ld, %ld, WideWideDivide()\n",
  290.             resultp->lo, remainder );
  291.  
  292.     resultp = WideMultiply( 32, 0x7FFFFFFF, &big2 );
  293.     tst_wide( resultp, 0xF, 0xFFFFFFE0, "WideMultiply()" );
  294.  
  295.     resultp = WideWideDivide( resultp, 4, &remainder );
  296.     if( (resultp->lo == 0xFFFFFFF8) && (resultp->hi == 3) && (remainder == 0) )
  297.         printf( "PASS" );
  298.     else
  299.         printf( "FAIL" );
  300.     printf( ": 0x%lx, 0x%lx, %ld, WideWideDivide()\n",
  301.             resultp->hi, resultp->lo, remainder );
  302.  
  303.     resultp = WideWideDivide( resultp, 16, &remainder );
  304.     if( (resultp->lo == 0x3FFFFFFF) && (resultp->hi == 0) && (remainder == 8) )
  305.         printf( "PASS" );
  306.     else
  307.         printf( "FAIL" );
  308.     printf( ": 0x%lx, 0x%lx, %ld, WideWideDivide()\n",
  309.             resultp->hi, resultp->lo, remainder );
  310.  
  311.     WideAssign32( &big1, 0x7FFFFFFF );
  312.     resultp = WideBitShift( &big1, -2 );
  313.     tst_wide( resultp, 1, 0xFFFFFFFC, "WideBitShift(pos, -2)" );
  314.  
  315.     resultp = WideBitShift( &big1, 1 );
  316.     tst_wide( resultp, 0, 0xFFFFFFFE, "WideBitShift(pos, 1)" );
  317.  
  318.     WideAssign32( &big1, -10 );
  319.     resultp = WideBitShift( &big1, 1 );
  320.     tst_wide( resultp, -1, -5, "WideBitShift(neg, 1)" );
  321.  
  322.     big1.hi = 0x80000000;
  323.     big1.lo = 0;
  324.     resultp = WideBitShift( &big1, -1 );
  325.     tst_wide( resultp, 0, 0, "WideBitShift(max neg, -1)" );
  326.  
  327.     big1.hi = 0x80000000;
  328.     big1.lo = 0;
  329.     resultp = WideBitShift( &big1, 1 );
  330.     tst_wide( resultp, 0xC0000000, 0, "WideBitShift(max neg, 1)" );
  331.  
  332.     big1.hi = 0;
  333.     big1.lo = 3;
  334.     resultp = WideShift( &big1, 1 );
  335.     tst_wide( resultp, 0, 2, "WideShift(pos, 1)" );
  336.  
  337.     big1.hi = 1;
  338.     big1.lo = 0xFFFFFFFF;
  339.     resultp = WideShift( &big1, 1 );
  340.     tst_wide( resultp, 1, 0, "WideShift(pos, 1)" );
  341.     resultp = WideShift( &big1, -1 );
  342.     tst_wide( resultp, 2, 0, "WideShift(pos, -1)" );
  343.  
  344.     /*------------------------------*/
  345.     printf( "<<< press ENTER for more >>>\n\n" );
  346.     getchar();
  347.  
  348.     big1.hi = 3;
  349.     big1.lo = 0xC0000000;
  350.     resultp = WideBitShift( &big1, 33 );
  351.     tst_wide( resultp, 0, 1, "WideBitShift(, 33)" );
  352.  
  353.     big1.hi = 3;
  354.     big1.lo = 0xC0000000;
  355.     resultp = WideBitShift( &big1, -33 );
  356.     tst_wide( resultp, 0x80000000, 0, "WideBitShift(, -33)" );
  357.  
  358.     big1.hi = 1;
  359.     big1.lo = 1;
  360.     resultp = WideShift( &big1, -1 );
  361.     tst_wide( resultp, 2, 2, "WideShift(pos, -1)" );
  362.  
  363.     big1.hi = -1;
  364.     big1.lo = -20;
  365.     resultp = WideShift( &big1, 2 );
  366.     tst_wide( resultp, -1, -5, "WideShift(neg, 2)" );
  367.     resultp = WideShift( &big1, 1 );
  368.     tst_wide( resultp, -1, -2, "WideShift(neg, 1)" );
  369.  
  370.     big1.hi = 0x80000000;
  371.     big1.lo = 0;
  372.     resultp = WideShift( &big1, -1 );
  373.     tst_wide( resultp, 0, 0, "WideShift(max neg, -1)" );
  374.  
  375.     big1.hi = 0x80000000;
  376.     big1.lo = 0;
  377.     resultp = WideShift( &big1, 1 );
  378.     tst_wide( resultp, 0xC0000000, 0, "WideShift(max neg, 1)" );
  379.  
  380.     big1.hi = 0;
  381.     big1.lo = 0x0000000C;
  382.     resultp = WideShift( &big1, 3 );
  383.     tst_wide( resultp, 0, 2, "WideShift Rounding" );
  384.  
  385.     big1.hi = 0x00000001;
  386.     big1.lo = 0x80000000;
  387.     resultp = WideShift( &big1, 32 );
  388.     tst_wide( resultp, 0, 2, "WideShift Rounding" );
  389.  
  390.     big1.hi = 0x00000001;
  391.     big1.lo = 0x00000000;
  392.     resultp = WideShift( &big1, 32 );
  393.     tst_wide( resultp, 0, 1, "WideShift Rounding" );
  394.  
  395.     big1.hi = 0;
  396.     big1.lo = 9;
  397.     result = WideSquareRoot( &big1 );
  398.     tst_long( result, 3, "WideSquareRoot(0,9)" );
  399.  
  400.     big1.hi = 0;
  401.     big1.lo = 0;
  402.     result = WideSquareRoot( &big1 );
  403.     tst_long( result, 0, "WideSquareRoot(0,0)" );
  404.  
  405.     big1.hi = 4;
  406.     big1.lo = 0;
  407.     result = WideSquareRoot( &big1 );
  408.     tst_long( result, 0x20000, "WideSquareRoot(4,0)" );
  409.  
  410.     big1.hi = 0x40000000;
  411.     big1.lo = 0;
  412.     result = WideScale( &big1 );
  413.     tst_long( result, 62, "WideScale()" );
  414.  
  415.     return 0;
  416. }
  417.  
  418. void tst_print3( wide *big1_ptr, wide *big2_ptr, wide *big3_ptr )
  419. {
  420.     tst_printint( big1_ptr );
  421.     printf( ", " );
  422.     tst_printint( big2_ptr );
  423.     printf( ", " );
  424.     tst_printint( big3_ptr );
  425.     printf( "\n" );
  426. }
  427.  
  428.  
  429. void tst_printint( wide *big_ptr )
  430. {
  431. char *outp;
  432. short  num_dig;
  433. decimal dec_str;
  434.  
  435.  
  436.     WideToDecStr( &dec_str, big_ptr );
  437.  
  438.     num_dig = dec_str.sig.length;
  439.     outp = (char *) &dec_str.sig.text[0];
  440.  
  441.     if( dec_str.sgn != 0 ) printf( "-" );
  442.  
  443.     while( num_dig-- > 0 )
  444.     {
  445.         printf( "%c", *outp++ );
  446.     }
  447. }
  448.  
  449.  
  450. void tst_compare3( wide *big1_ptr, wide *big2_ptr, wide *big3_ptr,
  451.                wide *save1_ptr, wide *save2_ptr, wide *save3_ptr, short equal_test )
  452. {
  453. short    tst1, tst2, tst3;
  454.  
  455.     printf( "\n" );
  456.  
  457.     if( equal_test )
  458.     {
  459.         tst1 = WideCompare( save1_ptr, big1_ptr );
  460.         tst2 = WideCompare( save2_ptr, big2_ptr );
  461.         tst3 = WideCompare( save3_ptr, big3_ptr );
  462.         if( (tst1 == 0) && (tst2 == 0) && (tst3 == 0) )
  463.             printf( "PASS" );
  464.         else
  465.             printf( "FAIL" );
  466.         printf( ": WideAdd32(), WideSubtract32, WideCompare() == 0\n" );
  467.     }
  468.  
  469.     tst1 = WideCompare( big1_ptr, big2_ptr );
  470.     tst2 = WideCompare( big1_ptr, big3_ptr );
  471.     tst3 = WideCompare( big2_ptr, big3_ptr );
  472.     if( (tst1 < 0) && (tst2 < 0) && (tst3 < 0) )
  473.         printf( "PASS" );
  474.     else
  475.         printf( "FAIL" );
  476.     printf( ": %d, %d, %d,  WideCompare() < 0\n", tst1, tst2, tst3 );
  477.  
  478.     tst1 = WideCompare( big3_ptr, big2_ptr );
  479.     tst2 = WideCompare( big3_ptr, big1_ptr );
  480.     tst3 = WideCompare( big2_ptr, big1_ptr );
  481.     if( (tst1 > 0) && (tst2 > 0) && (tst3 > 0) )
  482.         printf( "PASS" );
  483.     else
  484.         printf( "FAIL" );
  485.     printf( ": %d, %d, %d, WideCompare() > 0\n\n", tst1, tst2, tst3 );
  486.  
  487. }
  488.  
  489.  
  490. void tst_wide( wide *big_ptr, long hi, long lo, char *strp )
  491. {
  492.     if( (big_ptr->lo == lo) && (big_ptr->hi == hi) )
  493.          printf( "PASS" );
  494.     else
  495.         printf( "FAIL" );
  496.     printf( ": 0x%lx, 0x%lx, %s\n", big_ptr->hi, big_ptr->lo, strp );
  497. }
  498.  
  499. void tst_long( long actual, long expected, char *strp )
  500. {
  501.     if( actual == expected )
  502.          printf( "PASS" );
  503.     else
  504.         printf( "FAIL" );
  505.     printf( ": actual 0x%lx, expected 0x%lx, %s\n", actual, expected, strp );
  506. }
  507.  
  508. void __assertprint(char *filenam_ptr, char *linenum_ptr, char *expression_ptr)
  509. {
  510.     printf( "--- assert ---\n" );
  511.     printf( "%s, %s, %s\n", filenam_ptr, linenum_ptr, expression_ptr );
  512. }
  513.  
  514. void __assert_custom(char *filenam_ptr, char *linenum_ptr, char *expression_ptr)
  515. {
  516.     __assertprint( filenam_ptr, linenum_ptr, expression_ptr );
  517. }
  518.